Generative Software Engineering

Researching evermore abstract and powerful ways of composing programs is the meat of software engineering for half a century. Important early steps were subroutines (to encapsulate actions) and records (to encapsulate data). A large step forward came with the introduction of the object-oriented concepts (classes, subclasses and virtual methods) where classes can encapsulate both data and behaviors in a very powerful, but still flexible, way. For a long time, these concepts dominated the scene, but eventually the need for additional concepts became apparent. In this chapter, we focus on model driven engineering MDE, which complement and leverage other mechanism such generic constructs, aspect oriented programming AOP, component based software development CBSE, generative programming, domain specific languages

L'ingénierie des modèles

Performance, Silicomp-AQLPerformance, Silicomp-AQLCe que propose l'approche de l'ingénierie des modèles (IDM, ou MDE en anglais pour Model Driven Engineering) est de mécaniser le processus que les ingénieurs expérimentés suivent à la main. M{ê}me s'il existe une longue expérience de l'utilisation de l'ingénierie des modèles dans certains domaines comme les télécoms, sa généralisation à l'ensemble de l'industrie n'en est qu'à ses débuts. Visant à automatiser une partie du processus du développement, elle requiert un effort d'abstraction plus important de la part des développeurs. En contrepartie, elle permet de conserver le savoir faire de conception proche des centres de décision, g

Parallélisation d'un routeur XTP

International audienceWe study in this paper the feasibility of using general purpose distributed memory parallel computers to implement some functions of high speed networks. We concentrate on the switching problem of the XTP high performance protocol (dealing with the network and transport layers of the OSI stack). We use methods and tools developed within the PAMPA project (parallelizing methods, formal specification tools) to parallelize and prototype an XTP switching system on parallel architectures, and to make performance evaluations.Nous étudions dans cet article la faisabilité d'utiliser des machines parallèles à mémoire distribuée à usage général pour réaliser des fonctions de réseaux haut débit. Nous nous sommes intéressés au problème de la commutation dans le cadre du protocole XTP (protocole de gestion des couches réseau et transport pour les réseaux haut débit). Cette étude s'appuie sur les outils généraux développés dans le projet PAMPA (méthodes et outils de parallélisation et de validation) et a donné lieu à une évaluation de performance en fonction des types et tailles de machines utilisées

Parallèlisme massif et langage à objets : une approche SPMD

La plupart des langages à objets (LAO) parallèles utilise un modèle général de parallélisme fondé sur la notion de processus séquentiels communiquant à la CSP. Dans le contexte du calcul scientifique intensif, cette approche rend difficile la programmation efficace de machines massivement parallèles. C'est pourquoi nous proposons d'adopter pour ce type de langage une autre forme de parallélisme, connue sous le nom de parallélisme de données. Nous décrivons comment ce parallélisme de données peut être intégré dans un LAO séquentiel de manière simple et élégante - en utilisant uniquement les constructions du langage - afin d'exploiter la puissance potentielle des machines massivement parallèles à mémoires distribuées. Nous présentons ensuite EPEE, notre environnement parallèle d'execution de Eiffel, avec un exemple de son utilisation sur un paradigme bien connu dans le domaine du parallélisme (calculs sur des matrices). Après quelques remarques sur notre implantation, nous donnons quelques résultats expérimentaux de performances et nous concluons sur la généralité de notre approche

Safely Reusing Model Transformations through Family Polymorphism

International audienceThe engineering of systems involves many different stakeholders, each with their own domain of expertise. Hence more and more organizations are adopting Domain Specific Languages (DSLs) to allow domain experts to express solutions directly in terms of relevant domain concepts. This new trend raises new challenges about designing DSLs, evolving a set of DSLs and coordinating the use of multiple DSLs. In this talk we explore various dimensions of these challenges, and outline a possible research roadmap for addressing them. We detail one of these challenges, which is the safe reuse of model transformations.Indeed both DSL definition and tooling (e.g., checkers, document or code generators, model transformations) require significant development efforts, for a limited audience (by definition), because the current state of the art of Model Driven Engineering still makes it hard to reuse and evolve these definitions and tooling across several DSLs, even when these DSLs are conceptually very close to one other. We outline a new extension to the Kermeta language that leverages Family Polymorphism to allow model polymorphism, inheritance among DSLs, as well as evolution and interoperability of DSLs

Conception fonctionnelle de services d'entreprise fondée sur l'alignement entre coeur de métier et Système d'Information

National audienceThe enterprise organization must fulfil its strategy. Processes describing enterprise business core and enterprise organizational structure enable enterprise to meet this objective. This paper concerns business process driven design of customer oriented services. The description of business processes from customer instead of the production department allows indeed service set providing to the customer by the enterprise. In order to satisfy enterprise objectives, the service design procedure is so based on the Enterprise Architecture (EA) system point of view, whether services are computerized or not. Our service design procedure benefits from EA according to the enterprise strategy realization gap between the target Information System and the business core. This service design procedure adds an enterprise service automated design thanks to model driven engineering to the alignment so defined

The Design of GCCL: a Generalized Common Contract Language

Following its inception in Eiffel by Meyer and its diffusion to other environments (e.g., the standardisation of OCL as part of UML), Design by Contract now faces a major challenge in component-based software engineerin- g (CBSE). Compositional reasoning about system properties from component ones has been recently asserted by the SEI as the "key technical challenge" of CBSE, and contracts as a "key technical concept to support this vision". To live up to these expectations, DbC must tackle extra-functional properties of components and support Klein's "architectural-based attribute reasoning." Besides adopting the necessary new concepts, a good contract language must provide for abstraction, application, composition and scoping mechanisms in such a way to be used from modeling in UML to programming in standard languages (as seamless extensions to Java, C#, C++, Eiffel, and so on) through execution on traditional operating systems with minimal middleware additions. This paper examines conceptual foundations and design decisions to propose GCCL, a novel open generalized common contract language. GCCL is meant to be compatible with existing DbC (sub)languages, and especially OCL

Multimorphic Testing

International audienceThe functional correctness of a software application is, of course, a prime concern, but other issues such as its execution time, precision , or energy consumption might also be important in some contexts. Systematically testing these quantitative properties is still extremely difficult, in particular, because there exists no method to tell the developer whether such a test set is "good enough" or even whether a test set is better than another one. This paper proposes a new method, called Multimorphic testing, to assess the relative effectiveness of a test suite for revealing performance variations of a software system. By analogy with mutation testing, our core idea is to vary software parameters, and to check whether it makes any difference on the outcome of the tests: i.e. are some tests able to " kill " bad morphs (configurations)? Our method can be used to evaluate the quality of a test suite with respect to a quantitative property of interest, such as execution time or computation accuracy